var express = require("express");
var router = express.Router();
var db = require("../mysql/db");
const OpenAI = require("openai");

const openai = new OpenAI({
  apiKey: "sk-35abe5812cf0451a88d36acc02162396",
  baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1",
});

// 生成订单号函数
function generateOrderNumber() {
  const prefix = "ZWNLN";
  const timestamp = Date.now();
  const randomNum = Math.floor(1000 + Math.random() * 9000);
  const numberPart = `${timestamp}${randomNum}`;
  return `${prefix}${numberPart}`;
}

// 格式化当前时间为 YYYY-MM-DD HH:mm:ss
function formatDateTime(date) {
  const year = date.getFullYear();
  const month = String(date.getMonth() + 1).padStart(2, "0");
  const day = String(date.getDate()).padStart(2, "0");
  const hours = String(date.getHours()).padStart(2, "0");
  const minutes = String(date.getMinutes()).padStart(2, "0");
  const seconds = String(date.getSeconds()).padStart(2, "0");
  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
}

router.post("/api/ask", async (req, res) => {
  const { name, gender, birthYear, birthMonth, birthDay, birthHour, type } =
    req.body;

  console.log("Request body:", req.body);

  // 规范化参数，确保都是字符串，且 birthHour 有默认值
  const normalizedName = String(name || "").trim();
  const normalizedGender = String(gender || "").trim();
  const normalizedBirthYear = String(birthYear || "").trim();
  const normalizedBirthMonth = String(birthMonth || "").trim();
  const normalizedBirthDay = String(birthDay || "").trim();
  const normalizedBirthHour = birthHour ? String(birthHour).trim() : "未知";
  const normalizedType = String(type || "balanced").trim();

  if (
    !normalizedName ||
    !normalizedGender ||
    !normalizedBirthYear ||
    !normalizedBirthMonth ||
    !normalizedBirthDay
  ) {
    console.log("Missing required fields after normalization");
    return res
      .status(400)
      .json({ error: "请提供完整的个人信息", details: "缺少必填字段" });
  }

  console.log(
    `Received /api/ask request at ${new Date().toISOString()} for user ${normalizedName} with type ${normalizedType}`
  );

  let question;
  if (normalizedType === "近期事件") {
    question = `
      我是一个用户，以下是我的个人信息：
      姓名：${normalizedName}
      性别：${normalizedGender}
      出生日期：${normalizedBirthYear}年${normalizedBirthMonth}月${normalizedBirthDay}日
      出生时辰：${normalizedBirthHour}

      请根据我的生辰八字和个人信息，预测2025年的近期运势，重点关注以下内容：
      ### 近期事件
      未来3个月内可能发生的关键事件（事业、感情、财运等），按月分析，每月约50字。
      ### 运势趋势
      2025年上半年的运势走向，突出潜在机遇和风险，约80-100字。
      ### 建议与禁忌
      基于五行属性，给出未来3个月的行动建议和需要避免的行为，约80-100字。
      
      输出内容需简洁、预测性强，格式清晰，每部分以 ### 分隔标题。
    `;
  } else if (normalizedType === "紫微命盘") {
    question = `
      我是一个用户，以下是我的个人信息：
      姓名：${normalizedName}
      性别：${normalizedGender}
      出生日期：${normalizedBirthYear}年${normalizedBirthMonth}月${normalizedBirthDay}日
      出生时辰：${normalizedBirthHour}

      请基于紫微斗数分析2025年的运势，输出以下内容：
      ### 命盘解析
      用户的紫微命盘主要星曜和宫位特点，约100字。
      ### 流年运势
      2025年的事业、感情、财运的长期趋势，按季节分析，每季约50字。
      ### 建议与禁忌
      基于命盘的个性化建议和禁忌，约100字。
      
      输出格式清晰，每部分以 ### 分隔标题。如果无法生成具体内容，请明确说明原因，例如“数据不足，无法生成具体运势”。
    `;
  } else {
    question = `
      我是一个用户，以下是我的个人信息：
      姓名：${normalizedName}
      性别：${normalizedGender}
      出生日期：${normalizedBirthYear}年${normalizedBirthMonth}月${normalizedBirthDay}日
      出生时辰：${normalizedBirthHour}

      请根据我的生辰八字和个人信息，为我提供2025年的运势测算，输出内容必须结构化、均衡且详细，分为以下四个部分，每部分内容长度大致相等（约300-450字），并按季节（春、夏、秋、冬）分析,因为是总体分析所以事业、姻缘什么的后面不要带运势，直接就是事业然后下面是内容：
      ### 总体
      分析2025年的整体运势趋势，包括五行分析（我的生日五行与2025年大限五行的关系）以及全年的运势走向，按季节描述关键事件和趋势。
      ### 事业
      分析2025年的事业发展情况，涵盖工作机会、职业挑战和建议，按季节提供具体预测和应对策略。
      ### 姻缘
      分析2025年的感情运势，分别针对单身和有伴侣的情况，按季节描述感情发展、机遇和注意事项。
      ### 禁忌
      根据我的五行属性，列出2025年需要注意的禁忌（例如避免的环境、行为）以及积极建议（宜接触的事物、活动），按季节提供具体指导。

      输出格式必须清晰，每部分以 ### 分隔标题，确保内容均衡、具体，避免遗漏任何部分或季节。
    `;
  }

  try {
    // 检查订单重复
    const checkOrderQuery = `
      SELECT COUNT(*) as count 
      FROM orders 
      WHERE username = ? 
      AND order_time >= DATE_SUB(NOW(), INTERVAL 1 MINUTE)
    `;
    const [orderCheck] = await new Promise((resolve, reject) => {
      db.query(checkOrderQuery, [normalizedName], (err, results) => {
        if (err) {
          console.error("Error checking order:", err);
          return reject(err);
        }
        resolve(results);
      });
    });

    if (orderCheck.count > 0) {
      console.log(
        `Duplicate order detected for user ${normalizedName} with type ${normalizedType}`
      );
      return res.status(400).json({ error: "短时间内已生成订单，请稍后重试" });
    }

    // 插入订单
    const orderNumber = generateOrderNumber();
    const orderTime = formatDateTime(new Date());
    const username = normalizedName;
    const amount = 99.99;
    const status = "未支付";

    const insertOrderQuery =
      "INSERT INTO orders (order_number, username, order_time, amount, status) VALUES (?, ?, ?, ?, ?)";
    await new Promise((resolve, reject) => {
      db.query(
        insertOrderQuery,
        [orderNumber, username, orderTime, amount, status],
        (err, result) => {
          if (err) {
            console.error("Error inserting order:", err);
            return reject(err);
          }
          console.log(
            `Order created: ${orderNumber} for user ${username} with type ${normalizedType}`
          );
          resolve(result);
        }
      );
    });

    // 调用 AI 接口
    console.log("Calling OpenAI API with question:", question);
    const completion = await openai.chat.completions.create({
      model: "qwen-plus",
      messages: [
        {
          role: "system",
          content:
            "你是一个专业的八字算命大师，擅长提供详细、结构化的运势分析。",
        },
        { role: "user", content: question },
      ],
    });

    const aiAnswer =
      completion.choices[0]?.message?.content || "未收到有效回复";
    console.log("Raw AI response:", aiAnswer);

    // 插入运势记录
    const insertFortuneQuery =
      "INSERT INTO user_fortunes (username, birth_year, birth_month, birth_day, birth_hour, sex, fortune_type, fortune_data) VALUES (?, ?, ?, ?, ?, ?, ?, ?)";
    await new Promise((resolve, reject) => {
      db.query(
        insertFortuneQuery,
        [
          normalizedName,
          normalizedBirthYear,
          normalizedBirthMonth,
          normalizedBirthDay,
          normalizedBirthHour,
          normalizedGender,
          normalizedType || "八字测算",
          aiAnswer,
        ],
        (err) => {
          if (err) {
            console.error("Error inserting fortune:", err);
            return reject(err);
          }
          console.log(
            `Fortune saved for user ${normalizedName} with type ${normalizedType}`
          );
          resolve();
        }
      );
    });

    res.json({ answer: aiAnswer, orderNumber });
  } catch (error) {
    console.error("Error in /api/ask:", error);
    const status = error.status || 500;
    const details = error.message || "Unknown error";
    res.status(status).json({ error: "处理请求时出错", details });
  }
});

// 以下路由保持不变
router.get("/api/stats/orders", (req, res) => {
  const { startDate, endDate } = req.query;

  let queryParams = [];
  let dateCondition = "";
  if (startDate && endDate) {
    dateCondition = "WHERE order_time BETWEEN ? AND ?";
    queryParams = [startDate, endDate];
  }

  const totalQuery = `SELECT COUNT(*) as total FROM orders ${dateCondition}`;
  const statusQuery = `SELECT status, COUNT(*) as count FROM orders ${dateCondition} GROUP BY status`;
  const trendQuery = `SELECT DATE(order_time) as date, COUNT(*) as count FROM orders ${dateCondition} GROUP BY DATE(order_time) ORDER BY date`;

  Promise.all([
    new Promise((resolve, reject) => {
      db.query(totalQuery, queryParams, (err, results) => {
        if (err) return reject(err);
        resolve(results[0].total);
      });
    }),
    new Promise((resolve, reject) => {
      db.query(statusQuery, queryParams, (err, results) => {
        if (err) return reject(err);
        resolve(results);
      });
    }),
    new Promise((resolve, reject) => {
      db.query(trendQuery, queryParams, (err, results) => {
        if (err) return reject(err);
        resolve(results);
      });
    }),
  ])
    .then(([total, statusDistribution, trend]) => {
      res.json({
        total,
        statusDistribution,
        trend,
      });
    })
    .catch((err) => {
      console.error("Error fetching order stats:", err);
      res.status(500).json({ error: "Failed to fetch order stats" });
    });
});

router.get("/api/stats/fortunes", (req, res) => {
  const { startDate, endDate } = req.query;

  let queryParams = [];
  let dateCondition = "";
  if (startDate && endDate) {
    dateCondition = "WHERE created_at BETWEEN ? AND ?";
    queryParams = [startDate, endDate];
  }

  const totalQuery = `SELECT COUNT(*) as total FROM user_fortunes ${dateCondition}`;
  const typeQuery = `SELECT fortune_type, COUNT(*) as count FROM user_fortunes ${dateCondition} GROUP BY fortune_type`;
  const trendQuery = `SELECT DATE(created_at) as date, COUNT(*) as count FROM user_fortunes ${dateCondition} GROUP BY DATE(created_at) ORDER BY date`;

  Promise.all([
    new Promise((resolve, reject) => {
      db.query(totalQuery, queryParams, (err, results) => {
        if (err) return reject(err);
        resolve(results[0].total);
      });
    }),
    new Promise((resolve, reject) => {
      db.query(typeQuery, queryParams, (err, results) => {
        if (err) return reject(err);
        resolve(results);
      });
    }),
    new Promise((resolve, reject) => {
      db.query(trendQuery, queryParams, (err, results) => {
        if (err) return reject(err);
        resolve(results);
      });
    }),
  ])
    .then(([total, typeDistribution, trend]) => {
      res.json({
        total,
        typeDistribution,
        trend,
      });
    })
    .catch((err) => {
      console.error("Error fetching fortune stats:", err);
      res.status(500).json({ error: "Failed to fetch fortune stats" });
    });
});

router.get("/api/stats/users", (req, res) => {
  const { startDate, endDate } = req.query;

  let queryParams = [];
  let dateCondition = "";
  if (startDate && endDate) {
    dateCondition = "WHERE created_at BETWEEN ? AND ?";
    queryParams = [startDate, endDate];
  }

  const totalQuery = `SELECT COUNT(DISTINCT username) as total FROM user_fortunes ${dateCondition}`;
  const activeQuery = `SELECT COUNT(DISTINCT username) as active FROM user_fortunes WHERE created_at >= DATE_SUB(NOW(), INTERVAL 30 DAY)`;
  const trendQuery = `SELECT DATE(created_at) as date, COUNT(DISTINCT username) as count FROM user_fortunes ${dateCondition} GROUP BY DATE(created_at) ORDER BY date`;

  Promise.all([
    new Promise((resolve, reject) => {
      db.query(totalQuery, queryParams, (err, results) => {
        if (err) return reject(err);
        resolve(results[0].total);
      });
    }),
    new Promise((resolve, reject) => {
      db.query(activeQuery, [], (err, results) => {
        if (err) return reject(err);
        resolve(results[0].active);
      });
    }),
    new Promise((resolve, reject) => {
      db.query(trendQuery, queryParams, (err, results) => {
        if (err) return reject(err);
        resolve(results);
      });
    }),
  ])
    .then(([total, activeUsers, trend]) => {
      res.json({
        total,
        activeUsers,
        trend,
      });
    })
    .catch((err) => {
      console.error("Error fetching user stats:", err);
      res.status(500).json({ error: "Failed to fetch user stats" });
    });
});

router.get("/api/fortunes", (req, res) => {
  const { fortune_type, startDate, endDate } = req.query;

  let query = "SELECT * FROM user_fortunes";
  let queryParams = [];
  let conditions = [];

  if (fortune_type && fortune_type !== "全部") {
    conditions.push("fortune_type = ?");
    queryParams.push(fortune_type);
  }

  if (startDate && endDate) {
    conditions.push("created_at BETWEEN ? AND ?");
    queryParams.push(startDate, endDate);
  }

  if (conditions.length > 0) {
    query += " WHERE " + conditions.join(" AND ");
  }

  query += " ORDER BY created_at DESC";

  db.query(query, queryParams, (err, results) => {
    if (err) {
      console.error("Error fetching fortunes:", err);
      res.status(500).json({ error: "Failed to fetch fortunes" });
      return;
    }
    res.json(results);
  });
});

router.get("/api/users", (req, res) => {
  const query = `
    SELECT 
      username,
      COUNT(*) as fortune_count,
      MAX(created_at) as last_fortune_time
    FROM user_fortunes
    GROUP BY username
    ORDER BY last_fortune_time DESC
  `;

  db.query(query, (err, results) => {
    if (err) {
      console.error("Error fetching users:", err);
      res.status(500).json({ error: "Failed to fetch users" });
      return;
    }
    res.json(results);
  });
});

router.post("/api/orders", (req, res) => {
  const { username, order_time, amount, status } = req.body;
  if (!username || !order_time || !amount || !status) {
    return res.status(400).json({ error: "缺少必要字段" });
  }

  const order_number = generateOrderNumber();

  const query =
    "INSERT INTO orders (order_number, username, order_time, amount, status) VALUES (?, ?, ?, ?, ?)";
  db.query(
    query,
    [order_number, username, order_time, amount, status],
    (err, result) => {
      if (err) {
        console.error("Error creating order:", err);
        res.status(500).json({ error: "Failed to create order" });
        return;
      }
      res.json({
        id: result.insertId,
        order_number,
        username,
        order_time,
        amount,
        status,
      });
    }
  );
});

router.get("/api/orders", (req, res) => {
  const { status, order_number } = req.query;
  console.log("Received status:", status);
  console.log("Received order_number:", order_number);

  let query = "SELECT * FROM orders";
  let queryParams = [];
  let conditions = [];

  if (status && status !== "全部") {
    if (status === "待支付") {
      conditions.push("status = ?");
      queryParams.push("未支付");
    } else if (status === "已支付") {
      conditions.push("status = ?");
      queryParams.push("已支付");
    }
  }

  if (order_number) {
    conditions.push("order_number = ?");
    queryParams.push(order_number);
  }

  if (conditions.length > 0) {
    query += " WHERE " + conditions.join(" AND ");
  }

  query += " ORDER BY order_time DESC";

  console.log("Executing query:", query, "with params:", queryParams);

  db.query(query, queryParams, (err, results) => {
    if (err) {
      console.error("Error fetching orders:", err);
      res.status(500).json({ error: "Failed to fetch orders" });
      return;
    }
    console.log("Query results:", results);
    res.json(results);
  });
});

router.delete("/api/orders/:id", (req, res) => {
  const { id } = req.params;
  const query = "DELETE FROM orders WHERE id = ?";
  db.query(query, [id], (err) => {
    if (err) {
      console.error("Error deleting order:", err);
      res.status(500).json({ error: "Failed to delete order" });
      return;
    }
    res.json({ message: "Order deleted successfully" });
  });
});

router.put("/api/orders/:id", (req, res) => {
  const { id } = req.params;
  const { status } = req.body;
  const query = "UPDATE orders SET status = ? WHERE id = ?";
  db.query(query, [status, id], (err) => {
    if (err) {
      console.error("Error updating order:", err);
      res.status(500).json({ error: "Failed to update order" });
      return;
    }
    res.json({ message: "Order updated successfully" });
  });
});

//刘杰一生姻缘api接口
router.post("/api/marriage", async (req, res) => {
  const { name, gender, birthDate, birthTime, bazi } = req.body;
  console.log(req.body);
  // 校验必填字段
  if (!name || !gender || !birthDate || !bazi) {
    return res
      .status(400)
      .json({ error: "请提供完整的个人信息（姓名、性别、出生日期、八字）" });
  }

  const question = `
    我是用户，个人信息如下：
    姓名：${name}
    性别：${gender}
    出生日期：${birthDate}
    出生时辰：${birthTime}
    八字：${bazi}

    请根据我的生辰八字（${bazi}）和个人信息，详细分析一生的姻缘运势，包含以下方面：
    1. 整体姻缘趋势：一生的姻缘总体情况，是否容易遇到正缘。
    2. 单身阶段：不同年龄段的单身运势，遇到合适对象的时机建议。
    3. 恋爱阶段：恋爱中的相处建议，容易出现矛盾的时期及化解方法。
    4. 婚姻阶段：婚姻稳定性分析，夫妻关系调和建议。
    5. 不同季节对姻缘的影响：结合四季分析每个季节的姻缘特点及注意事项。
    6. 缘分出现的时机：根据生辰八字推算可能遇到重要缘分的时间段。
    7. 桃花运势：正桃花和烂桃花的分辨，避免烂桃花的建议。
    8. 家庭对姻缘的影响：家庭因素在姻缘中的作用及处理方式。
    9. 个人性格对姻缘的影响：分析性格特点如何影响姻缘，调整建议。
    10. 综合建议：根据五行等因素，给出提升姻缘运势的具体建议。

    要求每个分析紧密结合八字（${bazi}）和个人信息，内容详细具体。
  `;

  try {
    const completion = await openai.chat.completions.create({
      model: "qwen-plus",
      messages: [
        {
          role: "system",
          content:
            "你是专业的姻缘分析大师，擅长根据用户生辰八字（含八字信息）和个人信息分析姻缘走势，提供详细准确的指导。",
        },
        { role: "user", content: question },
      ],
    });

    const aiAnswer =
      completion.choices[0]?.message?.content || "未收到有效回复";
    res.json({ answer: aiAnswer });
  } catch (error) {
    console.error("AI 接口错误:", error);
    const status = error.status || 500;
    const details =
      error.code === "insufficient_quota" ? "API 限额已用尽" : error.message;
    res.status(status).json({ error: "AI 处理出错", details });
  }
});

// 刘杰合婚 api 接口
router.post("/api/marriage-compatibility", async (req, res) => {
  const { male, female } = req.body;

  // 校验必填字段
  if (
    !male ||
    !male.name ||
    !male.gender ||
    !male.bazi ||
    !female ||
    !female.name ||
    !female.gender ||
    !female.bazi
  ) {
    return res
      .status(400)
      .json({ error: "请提供完整的双方个人信息（姓名、性别、八字）" });
  }

  const maleName = male.name;
  const maleGender = male.gender;
  const maleBazi = male.bazi;

  const femaleName = female.name;
  const femaleGender = female.gender;
  const femaleBazi = female.bazi;

  const question = `
      我是用户，提供男女双方的个人信息如下：
      男方信息：
      姓名：${maleName}
      性别：${maleGender}
      八字：${maleBazi}

      女方信息：
      姓名：${femaleName}
      性别：${femaleGender}
      八字：${femaleBazi}

      请根据男女双方的生辰八字（男方：${maleBazi}，女方：${femaleBazi}）和个人信息，详细分析两人的合婚运势，包含以下方面：
      1. 整体合婚趋势：两人婚姻的总体适配情况，是否有良好的婚姻基础。
      2. 感情发展阶段：相识、相知、相恋各阶段的可能发展情况，是否容易出现感情危机。
      3. 性格匹配度：分析双方性格特点的互补或冲突之处，以及如何应对。
      4. 事业与家庭平衡：探讨两人在事业发展和家庭责任承担上的协调情况。
      5. 生育与子女问题：结合八字分析生育情况，以及子女对婚姻的影响。
      6. 经济状况：分析两人在经济观念和理财方式上的契合度，可能出现的经济问题及解决办法。
      7. 家庭关系：双方家庭对这段婚姻的影响，以及如何处理家庭矛盾。
      8. 不同季节对婚姻的影响：结合四季分析每个季节婚姻的特点及注意事项。
      9. 桃花运势对婚姻的影响：判断双方的桃花运势是否会对婚姻造成干扰，如何避免。
      10. 综合建议：根据五行等因素，给出提升两人婚姻运势的具体建议。

      要求每个分析紧密结合双方八字和个人信息，内容详细具体。
  `;

  try {
    const completion = await openai.chat.completions.create({
      model: "qwen-plus",
      messages: [
        {
          role: "system",
          content:
            "你是专业的合婚分析大师，擅长根据男女双方生辰八字（含八字信息）和个人信息分析合婚走势，提供详细准确的指导。",
        },
        { role: "user", content: question },
      ],
    });

    const aiAnswer =
      completion.choices[0]?.message?.content || "未收到有效回复";
    console.log("AI 返回的数据:", aiAnswer); // 打印 AI 返回的数据
    res.json({ answer: aiAnswer });
  } catch (error) {
    console.error("AI 接口错误:", error);
    const status = error.status || 500;
    const details =
      error.code === "insufficient_quota" ? "API 限额已用尽" : error.message;
    res.status(status).json({ error: "AI 处理出错", details });
  }
});

///刘家旺周易ai接口
router.post("/api/askss", async (req, res) => {
  const { name, gender, birthYear, birthMonth, birthDay, birthHour } = req.body;
  console.log(req.body)
  if (!name || !gender || !birthYear || !birthMonth || !birthDay) {
    return res.status(400).json({ error: "请提供完整的个人信息" });  
    
  }
 
  const question = `
    我是一个用户，以下是我的个人信息：
    姓名：${name}
    性别：${gender}
    出生日期：${birthYear}年${birthMonth}月${birthDay}日
    出生时辰：${birthHour}

    请根据我的生辰八字和个人信息，给我一个详细的2025年运势测算，包含以下方面：
    1. 五行分析：我的生日五行和大限五行（2025年的五行运势）。
    2. 事业运势：2025年的事业发展情况，按春夏秋冬四个季节分析。
    3. 姻缘运势：2025年的感情运势，单身和有伴侣的情况都要分析，按季节分析。
    4. 财运：2025年的财运情况，包括正财和偏财，按季节分析。
    5. 健康运势：2025年的健康状况，注意事项，按季节分析。
    6. 人际关系运势：2025年的人际交往情况，按季节分析。
    7. 家庭运势：2025年的家庭关系和亲情运势，按季节分析。
    8. 学业/进修运势：2025年的学习和自我提升运势，按季节分析。
    9. 贵人运势：2025年的贵人运和外部助力情况，按季节分析。
    10. 禁忌建议：根据我的五行属性，给出2025年需要注意的禁忌和建议，例如宜接触的事物、避免的环境等。

    请确保每个方面的分析都详细且具体，包含按季节的变化趋势和具体建议。
  `;

  try {
    const completion = await openai.chat.completions.create({
      model: "qwen-plus",
      messages: [
        { role: "system", content: "你是一个专业的周易算命大师，擅长根据用户的生辰八字和个人信息进行运势测算。" },
        { role: "user", content: question },
      ],
    });

    const aiAnswer = completion.choices[0]?.message?.content || "未收到有效回复";
    res.json({ answer: aiAnswer });
  } catch (error) {
    console.error("AI 接口错误:", error);
    const status = error.status || 500;
    const details = error.code === "insufficient_quota" ? "API 限额已用尽" : error.message;
    res.status(status).json({ error: "AI 处理出错", details });
  }
});
///刘家旺六爻ai接口
router.post("/api/asksse", async (req, res) => {
  const { name, gender, birthYear, birthMonth, birthDay, birthHour } = req.body;
  console.log(req.body)
  if (!name || !gender || !birthYear || !birthMonth || !birthDay) {
    return res.status(400).json({ error: "请提供完整的个人信息" });  
    
  }
 
  const question = `
    我是一个用户，以下是我的个人信息：
    姓名：${name}
    性别：${gender}
    出生日期：${birthYear}年${birthMonth}月${birthDay}日
    出生时辰：${birthHour}

    请根据我的生辰八字和个人信息，给我一个详细的2025年运势测算，包含以下方面：
    1. 五行分析：我的生日五行和大限五行（2025年的五行运势）。
    2. 事业运势：2025年的事业发展情况，按春夏秋冬四个季节分析。
    3. 姻缘运势：2025年的感情运势，单身和有伴侣的情况都要分析，按季节分析。
    4. 财运：2025年的财运情况，包括正财和偏财，按季节分析。
    5. 健康运势：2025年的健康状况，注意事项，按季节分析。
    6. 人际关系运势：2025年的人际交往情况，按季节分析。
    7. 家庭运势：2025年的家庭关系和亲情运势，按季节分析。
    8. 学业/进修运势：2025年的学习和自我提升运势，按季节分析。
    9. 贵人运势：2025年的贵人运和外部助力情况，按季节分析。
    10. 禁忌建议：根据我的五行属性，给出2025年需要注意的禁忌和建议，例如宜接触的事物、避免的环境等。

    请确保每个方面的分析都详细且具体，包含按季节的变化趋势和具体建议。
  `;

  try {
    const completion = await openai.chat.completions.create({
      model: "qwen-plus",
      messages: [
        { role: "system", content: "你是一个专业的六爻算命大师，擅长根据用户的生辰八字和个人信息,以及进行运势测算。" },
        { role: "user", content: question },
      ],
    });

    const aiAnswer = completion.choices[0]?.message?.content || "未收到有效回复";
    res.json({ answer: aiAnswer });
  } catch (error) {
    console.error("AI 接口错误:", error);
    const status = error.status || 500;
    const details = error.code === "insufficient_quota" ? "API 限额已用尽" : error.message;
    res.status(status).json({ error: "AI 处理出错", details });
  }
});

module.exports = router;
